﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using Studio7i.Dominio;
using Studio7i.Persistencia;

namespace Studio7i.Pruebas
{
    public class TestInstrumentoDAO
    {

        [TestFixture]
        public class Test1_instrumentoDAO
        {
            // Atributos a utilizar durante las pruebas
            private IInstrumentoDAO instrumentoDAO = null;
            private int codigoGenerado = 0;

            [TestFixtureSetUp]
            public void PrepararPruebas()
            {
                // 1. Definimos la implementación del DAO a probar

                instrumentoDAO = new Persistencia.InstrumentoDAO();
                
                // 2. Eliminamos todos los instrumentos en BD antes de las pruebas
                foreach (Instrumento instrumento in instrumentoDAO.ListarTodos())
                    instrumentoDAO.Eliminar(instrumento);
                // 3. Creamos datos para tenerlos disponibles en las pruebas
                instrumentoDAO.Crear(new Instrumento() { CodInst= 1, Tipo = "BATERIA", Marca = "PEARL", Modelo = "NUEVO", FechFabricacion = DateTime.ParseExact("1999","yyyy",null), Caracteristicas = "MADERA",CostoHora = 10, Estado = false });

            }
            [Test]
            public void Test1_Crear()
            {
                // 1. Clase a probar: InstrumentoDAO
                Assert.IsNotNull(instrumentoDAO);
                
                // 2. Declaramos e instanciamos la entidad de dominio
                Instrumento instrumentoACrear = new Instrumento();
                instrumentoACrear.Tipo = "BATERIA";
                instrumentoACrear.Marca = "PEARL";
                instrumentoACrear.Modelo = "NUEVO";
                instrumentoACrear.FechFabricacion = DateTime.ParseExact("1999", "yyyy", null);
                instrumentoACrear.Caracteristicas = "MADERA";
                instrumentoACrear.CostoHora = 10;
                instrumentoACrear.Estado = false;

                // 3. Declaramos la entidad que contendrá el resultado
                Instrumento instrumentoCreado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                // 5. Ejecutamos el método a probar
                    instrumentoCreado = instrumentoDAO.Crear(instrumentoACrear);
                    codigoGenerado = instrumentoCreado.CodInst;
                }, "Instrumento creado");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(instrumentoCreado);

                // Probamos que el código generado sea mayor a 0
                Assert.Greater(instrumentoCreado.CodInst, 0);

                // Probamos que el tipo registrado es igual al solicitado con la entidad

                Assert.AreEqual(instrumentoCreado.Tipo, instrumentoACrear.Tipo);
                // Probamos que la marca registrada es igual a la solicitada con la entidad
                Assert.AreEqual(instrumentoCreado.Marca, instrumentoACrear.Marca);
            }
            [Test]
            public void Test2_Obtener()
            {
                // 1. Clase a probar: InstrumentoDAO
                Assert.IsNotNull(instrumentoDAO);
                // 2. Definimos los datos para la prueba
                int codigo = codigoGenerado;
                // 3. Declaramos la entidad que contendrá el resultado
                Instrumento instrumentoObtenido = null;
                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                // 5. Ejecutamos el método a probar
                    instrumentoObtenido = instrumentoDAO.Obtener(codigo);
                });
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(instrumentoObtenido);
                Assert.AreEqual(instrumentoObtenido.CodInst, codigo);
                Assert.IsNotNullOrEmpty(instrumentoObtenido.Tipo);
                Assert.IsNotNullOrEmpty(instrumentoObtenido.Marca);
            }
            [Test]
            public void Test3_Modificar()
            {
                // 1. Clase a probar: InstrumentoDAO
                Assert.IsNotNull(instrumentoDAO);

                // 2. Declaramos e instanciamos la entidad de dominio
                Instrumento instrumentoAModificar = instrumentoDAO.Obtener(codigoGenerado);
                instrumentoAModificar.Tipo = "GUITARRA";
                instrumentoAModificar.Marca = "IBANEZ";
                instrumentoAModificar.Modelo = "FX3000";
                //instrumentoAModificar.FechFabricacion = DateTime.ParseExact("2005", "yyyy", null);
                //instrumentoAModificar.Caracteristicas = "NEGRA";
                //instrumentoAModificar.CostoHora = 15;
                //instrumentoAModificar.Estado = false;
                // 3. Declaramos la entidad que contendrá el resultado
                Instrumento instrumentoModificado = null;
                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                
                // 5. Ejecutamos el método a probar
                    instrumentoModificado = instrumentoDAO.Modificar(instrumentoAModificar);}, "Instrumento modificado");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(instrumentoModificado);

                // Probamos que el código generado sea mayor a 0
                Assert.AreEqual(instrumentoModificado.CodInst, codigoGenerado);

                // Probamos que el tipo registrado es igual al solicitado con la entidad
                Assert.AreEqual(instrumentoModificado.Tipo, instrumentoAModificar.Tipo);

                // Probamos que la marca registrada es igual a la solicitada con la entidad
                Assert.AreEqual(instrumentoModificado.Marca, instrumentoAModificar.Marca);
            }

            [Test]
            public void Test4_Eliminar()
            {
                // 1. Clase a probar:InstrumentoDAO
                Assert.IsNotNull(instrumentoDAO);

                // 2. Declaramos e instanciamos la entidad de dominio a eliminar
                codigoGenerado = 1;
                Instrumento instrumentoAEliminar = instrumentoDAO.Obtener(codigoGenerado);

                // 3. Declaramos la entidad que contendrá el resultado
                Instrumento instrumentoEliminado = null;

                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    instrumentoDAO.Eliminar(instrumentoAEliminar);
                }, "Instrumento eliminado");

                // Probamos que la entidad resultante no sea nula
                Assert.IsNull(instrumentoEliminado);

            }

            [Test]
            public void Test5_ListarTodos()
            {
                // 1. Clase a probar: InstrumentoDAO
                Assert.IsNotNull(instrumentoDAO);
                // 2. Declaramos la entidad que contendrá el resultado
                ICollection<Instrumento> instrumentosEncontrados = null;
                // 3. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    instrumentosEncontrados = instrumentoDAO.ListarTodos();
                }, "Instrumento eliminado");
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(instrumentosEncontrados);
                // Probamos que la cantidad de instrumentos encontrados sea 1
                Assert.AreEqual(instrumentosEncontrados.Count, 1);
                // Probamos que cada instrumento contenga la cadena de búsqueda en su nombre
                foreach (Instrumento instrumentoEncontrado in instrumentosEncontrados)
                {
                    Assert.IsNotNull(instrumentoEncontrado);
                    Assert.IsInstanceOf(typeof(Instrumento), instrumentoEncontrado);
                }
            }
            [Test]
            public void Test6_ListarXNombre()
            {
                // 1. Clase a probar: InstrumentoDAO
                Assert.IsNotNull(instrumentoDAO);
                // 2. Definimos los datos para la prueba
                string busqueda = "ter"; // Monterrico
                // 3. Declaramos la entidad que contendrá el resultado
                ICollection<Instrumento> instrumentosEncontrados = null;
                // 4. Probamos que no ocurra error al ejecutar el método
                Assert.DoesNotThrow(delegate
                {
                    // 5. Ejecutamos el método a probar
                    instrumentosEncontrados = instrumentoDAO.ListarXNombre(busqueda);
                });
                // Probamos que la entidad resultante no sea nula
                Assert.IsNotNull(instrumentosEncontrados);
                // Probamos que la cantidad de instrumentos encontrados sea 0
                Assert.AreEqual(instrumentosEncontrados.Count, 0);
                // Probamos que cada instrumento contenga la cadena de búsqueda en su nombre
                foreach (Instrumento instrumentoEncontrado in instrumentosEncontrados)
                {
                    Assert.IsTrue(instrumentoEncontrado.Tipo.Contains(busqueda));
                }
            }



        }
    }
}
